package sort;

import java.util.List;
import java.util.Scanner;

public class MySort {

//    public List<Integer> list sort0(){
//        return null;
//    }

    public int[] getModel(int i){
        int[] array=new int[i];
        return array;
    }

    public void testInput(){
        Scanner scanner=new Scanner(System.in);
        int i=scanner.nextInt();
        System.out.println("您输入的数字+1是："+(i+1));
        scanner.close();
    }

    public int[] getInput(){
        Scanner scanner=new Scanner(System.in);
        int[] a=new int[10];
        System.out.println("请输入10个数");
        for (int i = 0; i < 10; i++) {
            a[i]=scanner.nextInt();
        }
//        System.out.println("a.length="+a.length);
//        System.out.println("数组最大下标为L-1");
        scanner.close();
        return a;
    }

    public void printArray(int[] array){
        for (int i = 0; i < 10; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }

    //选择排序，测试0/9不能在头尾，
    //i是需要选举的官位，擂主与候选人依次pk，胜者成为擂主，迎接其他候选人的挑战。从总统选举到士兵，剩下那个直接成为平民，
    //j是候选者队列的游标，从i后面那个开始跟现任i对比，赢的成为I，
    //输的不变，继续呆在候选者队列，等待下一轮更次一级的官位选举。
    //官位从总统选举到士兵，从最大选到倒数第二，最后剩下的那1个候选人直接成为倒数第一/平民，
    public int[] sortSelect(int[] a){
        int tem=0;
        for (int i = 0; i < a.length-1; i++) {
            for (int j = i+1; j < a.length; j++) {
                if (a[i]>a[j]){
                    tem=a[i];
                    a[i]=a[j];
                    a[j]=tem;
                }
            }
        }
        return a;
    }
    //为什么冒泡排序比直接排序人气高？我猜：
    //在最差情况下，两人是一样的，n-1递减累加到1，
    //对比次数相同，可交换次数较少，
    // 冒泡会带来逆序数的减少，在冒泡子循环的无序队列的对比过程中，交换发生了，逆序数必减一，虽然不是在最终位置，但情况多少被改善了些，
    // 而直接排序只关心挑选最值，其他成员不会被改变，其他任何事情都不会被改变，
    //当候选人成功上位，此刻逆序数减少n-1-i，递减累加到1，
    //错误：下一轮官位必在其前，所以即使丢位，逆序数还是减一了，但一轮循环，也就减一了而已，
    //错误：候选人上位后又下台，会被安排在次一级官位，上位后不会下台，
    //但某些情况下，在运气好的情况下，冒泡出奇迹，
    //直接排序，不存在，当运气好的时候，性能爆发，平均值比不了，

    //从第一和第二开始，两两相互比较，大的站后位，跟再后面一位比较，大的站后位，
    //最终移动到了队尾，后面没人再PK了，此时最大的已经站在了最后面，
    //然后无序队列长度减一，
    //继续两两比较，最大的站到最后，
    //然后无序队列长度减一，
    //当无序队列长度为2，无序队列 排序结束，意味着全数组排序结束，所以无序队列长度>1，
    //选择变量，无序队列游标，无序队列长度，无序队列队头/队尾下标，有序队列长度，

    //两种排序都是将总队列，分为有序和无序两部分，
    //区别在于，直接排序是擂台赛，N场，官位是变量，无序队列的起点是变量，
    //冒泡排序是淘汰赛/推举制，排挤出去，从差劲的到，最终成为最差劲的，无序队列的长度是变量，
    //内层循环都是对无序队列的遍历选举，

    //必定变量，无序队列游标，
    //需知变量，无序队列游标的，最大值or最小值，
    //无序队列游标的最值，是变量，由外层循环，动态决策，

    //获得无序队列长度，可得无序队列-队尾下标，
    //获得无序队列长度，已知队列总长度L，L-，可得有序队列长度，
    //已知有序队列长度，加一，可得无序队列-队头下标，
    //自己冒泡，尾定法，从队头开始比较，
    public int[] sortBubble_Head(int[] a){
        for (int i = a.length; i>0; i--) {
            for (int j = 0; j < i-1; j++) {
                int tem=0;
                if (a[j]>a[j+1]) {
                    tem=a[j];
                    a[j]=a[j+1];
                    a[j+1]=tem;
                }
            }
        }
        return a;
    }

    //自己冒泡，头定法，从队尾开始比较，
    public int[] sortBubble_Foot(int[] a){
        for (int i = 0; i<a.length; i++) {
            for (int j = a.length; j>i; j--) {
                int tem=0;
                if (a[j]>a[j-1]) {
                    tem=a[j];
                    a[j]=a[j-1];
                    a[j-1]=tem;
                }
            }
        }
        return a;
    }

    //案例冒泡，换个角度，
    public int[] sortBubble_Demo(int[] a){
        for (int i = 0; i<a.length; i++) {
            for (int j = 0; j <a.length- i-1; j++) {
                int tem=0;
                if (a[j]>a[j+1]) {
                    tem=a[j];
                    a[j]=a[j+1];
                    a[j+1]=tem;
                }
            }
        }
        return a;
    }

    //在for括号内定义的元素，在for外查无此人，
    //在for括号内定义的元素，在for内当然可以被修改，
    //for循环测试
    public void printFor(){
        for (int i = 0; i < 3; i++) {
            System.out.println("内层循环执行前i="+i);
            for (; i < 5; i++) {
                System.out.println("i="+i);
            }
            System.out.println("内层循环执行后i="+i);
        }

    }

    //错误错误错误错误错误错误错误错误错误
    //插入排序
    //i是不断被添加插入，有序队列的元素，在有序队列最后一个元素的后面，元素间隔为1，后序元素不断成为i（i++），被加入到有序队列，
    //j是有序队列的游标指针，从队列第一个元素到队列最后一个元素，队列长度是i-1,
    //有序数组的长度，j的最大值，
    //被插入的值的下标，
    //全部数组分为有序数组、待插入元素数组，
    //有序数组分为不需挪位数组、需挪位元素数组，
    //三层循环，遍历带插入数组，遍历比对有序数组成员，遍历需挪移数组执行后移，
    public int[] sort1_1(int[] a){
        //遍历起点，最初的有序数组的-最末位元素的后一位-的元素，
        //因为最初的有序数组只有一个值，即整体数组的初值，
        //所以i的初值就是整体数组的第2个值，
        //遍历终点，整体数组的最后一个值，
        for (int i = 1; i < a.length; i++) {
            //遍历起点，有序数组的第一个值，即为整体数组的第一个值，
            //遍历终点，有序数组的最后一个值，即i前面那个值，
            for (int j = 0; j < i; j++) {
                int tem=0;
                //比人家大，就不能抢人家位置，得继续往后站，
                //直到找到一个比自己大的，因为是有序数组，所以后面全是比自己大的，
                //让他们全都后移，给自己腾出个空位，然后自己再坐下
                if (a[i]<a[j]){
                    //a[i]要插在a[j]的位置，a[j]及其后置位元素，全部后退，
                    // 从最末位开始后退，最末位下标越界，退出有序数组，退到最大下标加一的位置，即是退到a[i]的位置上，
                    //a[i]的值暂存到tem里，待j等回退完成，在a[j]处誊出一个空位，将a[i]的值插在a[j]的位置上，
                    //从有序队列的末位开始，逐个后移，直到J后移完成，最后操作为a[j+1]=a[j]
                    //k是否可以不存在，用i/k代替？会影响外围的吧，
                    //挪移前准备，暂存a[i]的值，tem=a[i]
                    //起始挪移a[i]=a[i-1]，that is lastMember of  needRetreatArray and SortArray.
                    //最终挪移a[j+1]=a[j]，that is the first who need retreat in SortArrayMember
                    //最终插入a[j]=tem，that is valueOf_a[i]
                    tem=a[i];
                    for (int k=i; k >j+2; k--) {
                        a[k]=a[k-1];
                    }
                    a[j]=tem;
                    //执行完插入，应该结束针对此值的操作，结束2层循环，让第一层循环放入新值，
                    //二层循环只是遍历对比，三层循环是后挪并插入，
                    //三层循环结束，二层循环也就没有进行进行的必要的，
                    //所以break结束二层循环，开始新的一层循环值，
                    break;
                }
            }
        }
        return a;
    }
//            您输入的是：
//            5 3 8 0 1 9 7 4 6 2
//            排序结果是：
//            0 1 2 6 8 8 8 8 8 9
//            结论：程序错误，为什么会出现重复元素？和元素丢失？
    //机械尝试，删去a[j]=tem;之后的break;
//    sort1的排序结果是：0 3 3 3 3 3 4 4 7 8，趋势递增，但是错误，

    //以首个元素为最初有序队列，从第二个元素开始执行插入，论到最后一个元素执行完毕结束插入，
    //j的取值范围，初值为0，终值为有序数组的最后一位，有序数组的最后一位的后一位是i，所以，有序数组的最后一位是i-1,
    //k的取值范围，从后往前逐个后移，初值为有序数组的最后一位，终值为被i击败那位，他们都被赋值给+1位，
    //5 6 3 2 1 9 0 4 7 8
    //i=1，j=0，a[i]=6，a[j]=5，a[i]!<a[j]，j++,j=1，j!<i，二层循环结束，
    //i=2，j=0，a[i]=3，a[j]=5，a[i]<a[j]，tem=a[i]=3，
    //i=2,j=0,k=2,应该允许后移，
    // k=i=2,j=0,k!>j+2，错误，
    //k的取值范围，应该是从i到j+1,
    //k必须大于j，才能接收j的值后移，所以应该是K>j，而不是k>j+2,
    //k>j，才能取值k=j+1，k>j+2,那取值就是K=J+3，加减想反了，
    // a[2]=a[1]=
    //插入排序，无注释版，自创三重循环
    public int[] sortInsert_My3(int[] a){
        for (int i = 1; i < a.length; i++) {
            for (int j = 0; j < i; j++) {
                if (a[i]<a[j]){
                    int tem=a[i];
                    for (int k=i; k >j; k--) {
                        a[k]=a[k-1];
                    }
                    a[j]=tem;
                    break;
                }
            }
//            MySort mySort=new MySort();
//            System.out.println(i+"轮排序结果为：");
//            mySort.printArray(a);
        }
        return a;
    }

    //插入排序，无注释版，
    public int[] sortInsertDemo(int[] a){
        for (int i = 1; i < a.length; i++) {
            for (int j = 0; j < i; j++) {
                if (a[i]<a[j]){
                    int tem=a[i];
                    for (int k=i; k >j; k--) {
                        a[k]=a[k-1];
                    }
                    a[j]=tem;
                    break;
                }
            }
//            MySort mySort=new MySort();
//            System.out.println(i+"轮排序结果为：");
//            mySort.printArray(a);
        }
        return a;
    }

    //除不尽怎么办？向下取整？
    //除法测试,果然是向下取整，
    public void divTest(int i){
        System.out.println(i/2);
    }

    //希尔排序，增量排序，插入排序plus,
    //不再是i++，而是i=i+n，
    //谁都增量变了，不至于是全部吧，应该是2层循环的，外层还是要遍历的，只是上限变成了n，而不是l，
    //i的上限是n，j的增量是n，
    //增量也在变，控制增量值的才是最外层。中层把n当上限，下层把n当增量，就是把for循环的第三个条件给改了呗，有什么大不了的，
//    public int[] sortShell_v1(int[] a){
//
//        int l=a.length;
//        //i为增量，j为分组游标，k为元素游标，m为被挪移元素游标，
//        //增量序列5,2,1，
//        for (int i = l/2; i >0; i=i/2) {
//            for (int j = 0; j < i; j++) {
//                //从分数组的第二个元素开始，遍历未排序的数组元素，
//                //增量没有游标，起点是l/2，终点是1，
//                //分组的游标，是0++，终点是增量，
//                // 无序数组的游标，是有序数组的l+i+i+i...，长度上限为全部数组的L，起点是分组游标+增量，
//                  //因为有序数组的长度在+i，所以无序数组的长度也在一直随着+i,
//                // a[k]是有序数组的游标，从j开始，j+i+i+i...，长度上限随循环递增，起点是分组游标，
//                //挪移数组的游标，是从有序数组的l，到被选中元素,
//                //无序数组的游标，其实j+i没错，缺了一层吗？
//                for (int k = j+i; k < l && k+i<l ; k+=i) {
//                    //有序数组的游标，从j开始，上限是？上限在递增，被i限制吧，
//                    for (int m = j; m < k; m+=i) {
//                        if (a[k]<a[m]){
//                            int tem=a[k];
//                            //从要插入的元素，前面那个元素开始，挪动插入，挪到那个被比较的有序数列元素结束，
//                            //因为n>m，所以n-i的最小值就是m,
//                            for (int n = k; n >m && n>0; n-=i) {
//                                a[n]=a[n-i];
//                            }
//                            a[m]=tem;
//                            break;
//                            //if触发，就该换K触发无序数组遍历了，继续遍历有序数组m没意义，
//                            //假如没有break，a[k]会尝试往后插入，它总能成功，最终在每个元素之前都插入了一个他，
//                            // 8597，a2-5插入了：
//                            // 5897，循环继续,a2还在跟后面的比较，现在是a2-8,并不能a2不能越界，
//                            //987654，a4插入987，不可能，789689，
//                            //a4-6尝试插入，插入成功，结果678989，循环继续，a4-9尝试插入，那不可能，
//                            // 现在a4已经处于有序数组了，被插入元素的位置是最大的，他这个位置注定了他最大，
//                            // 会继续比较，但不会发生插入，因为他最大，
//                            //所以没有break不会出错，有了break会不会出错呢？
//
//                        }
//                    }
//                }
//            }
//        }
//        return a;
//    }
    //您输入的是：
    //5 3 8 0 1 9 7 4 6 2
    //正在执行插入排序...
    //sortShell的排序结果是：
    //0 1 3 4 5 6 7 8 9 2 错误，
    // i为增量，j为分组游标-规定各组起点，k为无序队列首个元素游标，m为被挪移元素游标，
    public int[] sortShell_my(int[] a){
        int l=a.length;
        // i为增量，从长度减半开始，到1结束，
        for (int i = l/2; i >0; i=i/2) {
            //j为分组游标，规定各组起点，从数组首个元素开始，到增量结束，
            for (int j = 0; j < i; j++) {
                //遍历无序队列，k为无序队列首个元素游标，从分数组第二个元素开始，结束于最大值，现在并没有用到k+i，不需要这个条件，
                for (int k = j+i; k < l ; k+=i) {
                    //m为有序数组的游标，从首个元素j开始，上限是插入元素的前一位。
                    for (int m = j; m < k; m+=i) {
                        if (a[k]<a[m]){
                            int tem=a[k];
                            //n为被挪移元素游标，从插入元素前一位开始，到被PK的元素位结束，n>m保障n-i=m，
                            for (int n = k; n >m; n-=i) {
                                a[n]=a[n-i];
                            }
                            a[m]=tem;
                            break;
                        }
                    }
                }
            }
        }
        return a;
    }

    //希尔排序抽出来的，两次循环的插入排序，排序执行成功!
    public int[] sortI(int[] a){
        for (int x = 0; x< 1; x++) {//对于gap所分的每一个组
            for (int i = x+ 1; i < a.length; i= i + 1) {      //进行插入排序
                int temp= a[i];
                int j;
                for (j= i - 1; j>= 0 && a[j] > temp;j = j - 1){
                    a[j+ 1] = a[j];
                }
                a[j+ 1] = temp;
            }
        }
        return a;
    }

    //错误
    // 5 3 8 0 1 9 7 4 6 2
    // 3 5 0 1 8 7 4 6 2 9
    //插入排序优化,尾插法，三层变两层
    public int[] sortInsert_error1(int[] a){
        for (int i = 0+1; i < a.length; i++) {
            for (int j = i-1; j >=0; j--) {
                if (a[i]<a[j])
                {
                    int tem=a[i];
                    a[i]=a[j];
                    a[j]=tem;
                }
                break;
            }
        }
        return a;
    }

    //错误
    // 5 3 8 0 1 9 7 4 6 2
    //5 5 8 8 8 9 9 9 9 9
    //报错j>=0总是true，int类型最小值是0，所以不需要判断非负数，那循环条件总不能为空吧？
    //插入排序优化,尾插法，三层变两层
    //修改i=0+1为i=1，删除j>=0，删除break，
    //如果队尾比i大，就后移，而非交换，
    //如果遇到了比自己小的，就在后面坐下，结束循环，
    public int[] sortInsert_e2(int[] a){
        for (int i = 0+1; i < a.length; i++) {
            for (int j = i-1; ; j--) {
                int tem=a[i];
                if (a[i]<a[j])
                {
                    a[j+1]=a[j];
                }else {
                    a[j+1]=tem;
                }
                break;

            }
        }
        return a;
    }

    //错误
    //5 3 8 0 1 9 7 4 6 2
    //5 5 8 8 8 9 9 9 9 9
    //递增排序
    //把break放进else里
    public int[] sortInsert_e3(int[] a){
        for (int i =1; i < a.length; i++) {
            for (int j = i-1;j>=0 ; j--) {
                int tem=a[i];
                if (a[i]<a[j])
                {
                    a[j+1]=a[j];
                }else {
                    a[j+1]=tem;
                    break;
                }
            }
        }
        return a;
    }

    //错误
    //尾插法，被插入元素也该从后往前选择，那永远选择数组最后那个呗，直到有序数组长度=整体数组长度，
    //没必要，只后移一位，无序数组的其他成员是不受影响的，
    //被插入元素暂存，对比个位，所以应该是tem被插入元素的值进行对比，而不是被插入元素坐标吗？
    //毕竟在初次后移，被插入元素的住址，已经换人了，
    public int[] sortInsert_e4(int[] a){
        for (int i =1; i < a.length; i++) {
            for (int j = i-1;j>=0 ; j--) {
                int tem=a[i];
//                System.out.println(a[i]);
//                System.out.println(a[j]);
                MySort mySort=new MySort();
                if (a[i]<a[j])
                {
//                    System.out.println("if a[j]="+a[j]);
//                    System.out.println("if a[j+1]="+a[j+1]);
                    System.out.println("执行后移");
                    a[j+1]=a[j];
//                    System.out.println("if a[j]="+a[j]);
//                    System.out.println("if a[j+1]="+a[j+1]);

                    mySort.printArray(a);
                }else {
                    //else每次都执行了，why?
                    a[j+1]=tem;
//                    System.out.println("else:"+a[j+1]);
                    System.out.println("执行插入");
                    mySort.printArray(a);
                    break;
                }
            }
        }
        return a;
    }

    //错误
    //5 3 8 0 1 9 7 4 6 2
    //5 5 8 8 8 9 9 9 9 9
    //将if条件的a[i]改为tem
    public int[] sortInsert_e5(int[] a){
        for (int i =1; i < a.length; i++) {
            for (int j = i-1;j>=0 ; j--) {
                int tem=a[i];
                MySort mySort=new MySort();
                if (tem<a[j])
                {
                    a[j+1]=a[j];
                    System.out.println("执行了后移");
                    mySort.printArray(a);
                }else {
                    System.out.println("执行了插入");
                    mySort.printArray(a);
                    a[j+1]=tem;
                    break;
                }
            }
        }
        return a;
    }

    //错误
    //5 3 8 0 1 9 7 4 6 2
    //5 0 1 2 3 4 6 7 8 9
    //将int tem=a[i];移入外层循环，
    //5 3 8 0 1 9 7 4 6 2
    //理想情况
    //5 5 8 0 1 9 7 4 6 2，3<5，a[i]<a[j]，tem<a[j],执行后移
    //3 5 8 0 1 9 7 4 6 2，j--，前面没人了，内层循环结束，执行插入，
    //把a[j+1]=tem放在外层循环中？那就没j的值了呀，凭借i是不能确定j的值的，
    //if j=0，后移，然后直接插入，if嵌套，

    public int[] sortInsert_e6(int[] a){
        for (int i =1; i < a.length; i++) {
            int tem=a[i];
            for (int j = i-1;j>=0 ; j--) {
                MySort mySort=new MySort();
                if (tem<a[j])
                {
                    a[j+1]=a[j];
                    System.out.println("执行了后移");
                    mySort.printArray(a);
                    if (j==0){
                        a[j+1]=tem;
                        System.out.println("if执行了插入");
                        mySort.printArray(a);

                    }
                }else {
                    a[j+1]=tem;
                    System.out.println("else执行了插入");
                    mySort.printArray(a);
                    break;
                }
            }
        }
        return a;
    }

    //当j=0，修改a[j+1]=tem;为a[j]=tem;
    public int[] sortInsert_test(int[] a){
        for (int i =1; i < a.length; i++) {
            int tem=a[i];
            for (int j = i-1;j>=0 ; j--) {
                MySort mySort=new MySort();
                if (tem<a[j])
                {
                    a[j+1]=a[j];
                    System.out.println("执行了后移");
                    mySort.printArray(a);
                    if (j==0){
                        a[j]=tem;
                        System.out.println("if执行了插入");
                        mySort.printArray(a);

                    }
                }else {
                    a[j+1]=tem;
                    System.out.println("else执行了插入");
                    mySort.printArray(a);
                    break;
                }
            }
        }
        return a;
    }

    public int[] sortInsert(int[] a){
        for (int i =1; i < a.length; i++) {
            int tem=a[i]; //在内循环中，a[i]的值是动态的，所以需要在循环外备份，
            for (int j = i-1;j>=0 ; j--) {
                MySort mySort=new MySort();
                if (tem<a[j])
                {
                    a[j+1]=a[j];
                    if (j==0){ //因为是先腾出空位，直到遇到更小的才在它后面坐下，可如果因为前面没人循环结束，数据就丢失了，
                        a[j]=tem;
                    }
                }else {
                    a[j+1]=tem;
                    break;
                }
            }
        }
        return a;
    }

    //错误
    //5 3 8 0 1 9 7 4 6 2
    //0 9 9 9 9 9 9 9 9 9
    public int[] sortShell_m2_e1(int[] a){
        int l=a.length;
        for (int i = l/2; i >0 ; i=i/2) {
            for (int j = 0; j < i; j++) {
                //插入排序
                for (int k = j+i; k < l; k=k+i) {
                    int tem=a[k];
                    for (int m = k-i; m >=0; m-=i) {
                        if (tem<a[m]){
                            a[m+i]=a[m];
                            if (m<i){ //原装是m==0,
                                a[m]=tem;
                            }
                        }else {
                            a[m+i]=tem;
                        }
                    }
                }
            }
        }
        return a;
    }


    //如果增量是1，分组只能为0，j<i而不是j<i-1，
    //添加break之后，排序正确，
    public int[] sortShell_m2(int[] a){
        int l=a.length;
        for (int i = l/2; i >0 ; i=i/2) {
            for (int j = 0; j < i; j++) {
                //插入排序
                for (int k = j+i; k < l; k=k+i) { //无序队列的起点是第二个元素，
                    int tem=a[k];
                    for (int m = k-i; m >=0; m-=i) { //有序遍历的起点是被插前一个元素，有序最后一个元素，
                        if (tem<a[m]){
                            a[m+i]=a[m];
                            if (m<i){ //原装是m==0,
                                a[m]=tem;
                            }
                        }else {
                            a[m+i]=tem;
                            break;//如果没有break，当前元素的下一位总会被修改为tem，
                        }
                    }
                }
            }
        }
        return a;
    }

    public int[] mergeArrays(int[] a1,int m,int[] a2,int n){

        n=a2.length;
        m=a1.length-n;

        while (n>=0&&m>=0){
            if(a1[m]>a2[n]){
                a1[m+n]=a1[m];
                m--;
            }else {
                a1[m+n]=a2[n];
                n--;
            }
        }

        return a1;
    }


    public static void main(String[] args) {
        MySort mySort=new MySort();

        //请输入十个数：5 3 8 0 1 9 7 4 6 2
        int[] array=mySort.getInput();
        System.out.println("您输入的是：");
        mySort.printArray(array);

        array=mySort.sortShell_m2(array);

        System.out.println("排序结果是：");
        mySort.printArray(array);


        //请输入十个数：5 3 8 0 1 9 7 4 6 2
//        int[] array=mySort.getInput();
//        mySort.printArray(array);
//        array=mySort.sortI(array);
//        mySort.printArray(array);


//        //请输入十个数
//        int[] array=mySort.getInput();
//        System.out.println("您输入的是：");
//        mySort.printArray(array);
//        System.out.println("正在执行插入排序...");
//        array=mySort.sortInsert(array);
//        System.out.println("sortInsert的排序结果是：");
//        mySort.printArray(array);

//        mySort.divTest(5);
//        mySort.printFor();

        //请输入十个数
//        int[] array=mySort.getInput();
//        System.out.println("您输入的是：");
//        mySort.printArray(array);
//        array=mySort.sort1(array);
//        System.out.println("sort1的排序结果是：");
//        mySort.printArray(array);

//        array=mySort.sortArray6(array);
//        System.out.println("666的排序结果是：");
//        mySort.printArray(array);

//        array=mySort.sortArray5(array);
//        System.out.println("555的排序结果是：");
//        mySort.printArray(array);

//        array=mySort.sortArray1(array);
//        System.out.println("111的排序结果是：");
//        mySort.printArray(array);

    }
}
